home *** CD-ROM | disk | FTP | other *** search
/ MIDICraft's MIDINET CD-ROM / MIDICraft's MIDINET CD-ROM.iso / DOSUTILS / KORG / MIDIIO.CPP < prev    next >
C/C++ Source or Header  |  1996-11-01  |  42KB  |  2,116 lines
  1. // midiio.cpp written by Günter Nagler 1995 (gnagler@ihm.tu-graz.ac.at)
  2. #include "midiio.hpp"
  3. #include <assert.h>
  4. #ifdef __MSDOS__
  5. #include <mem.h>
  6. #endif
  7. #include <string.h>
  8. #include <stdlib.h>
  9.  
  10. static char* copyright = "midiio v1.4 (c) 1995 by Günter Nagler (" __DATE__ ")";
  11.  
  12. int compress = 1;
  13.  
  14. #define NOTREALISTIC_PAUSE 0x1000000UL
  15.  
  16. // common sysex events
  17. unsigned char sysex_gmreset[] = { 0xF0, 0x7E, 0x7F, 0x09, 0x01, 0xF7 };
  18. unsigned char sysex_gsreset[] = { 0xF0, 0x0A, 0x41, 0x10, 0x42, 0x12, 0x40, 0x00, 0x7F, 0x00, 0x41, 0xF7 };
  19. unsigned char sysex_gsexit[] =  { 0xF0, 0x0A, 0x41, 0x10, 0x42, 0x12, 0x40, 0x00, 0x7F, 0x7F, 0x42, 0xF7 };
  20. unsigned char sysex_xgreset[] = { 0xF0, 0x08, 0x43, 0x10, 0x4C, 0x00, 0x00, 0x7E, 0x00, 0xF7 };
  21.  
  22. static int issysex(unsigned char* sysex, char* sysdata, int syslen)
  23. {
  24.   if (*sysex == 0xF0)
  25.     sysex++;
  26.   while (syslen > 0)
  27.   {
  28.     if (*sysex != *sysdata)
  29.       return 0;
  30.     syslen--;
  31.     if (*sysex == 0xF7)
  32.       break;
  33.     sysex++;
  34.     sysdata++;
  35.   }
  36.   return (syslen != 0) ? 0 : 1;
  37. }
  38.  
  39. static int sysexlen(unsigned char* sysex)
  40. {
  41. int len = 0;
  42.  
  43.   len = 0;
  44.   while (*sysex != 0xF7)
  45.   {
  46.     sysex++;
  47.     len++;
  48.   }
  49.   return len+1; // incl. F7
  50. }
  51.  
  52. // class MidiRead
  53.  
  54. const char* MidiRead::copyright()
  55. {
  56.   return (const char*)::copyright;
  57. }
  58.  
  59. MidiRead::MidiRead(const char* filename, FILE* f)
  60. {
  61.   midiname_ = filename;
  62.   if (f)
  63.   {
  64.     f_ = f;
  65.     shouldclose_ = 0;
  66.   }
  67.   else
  68.   {
  69.     shouldclose_ = 1;
  70.     if (!filename)
  71.       f_ = 0;
  72.     else
  73.       f_ = fopen(filename, READ_BINARY);
  74.   }
  75.  
  76.   buflen_ = 0;
  77.   bufpos_ = 0;
  78.   curpos_ = 0;
  79.   pos_ = 0;
  80.   curchannel_ = NOCHANNEL;
  81.   curtime_ = 0;
  82.   options_ = 0;
  83.   if (f_)
  84.   {
  85.     fseek(f_, 0L, SEEK_END);
  86.     filesize_ = ftell(f_);
  87.     fseek(f_, 0L, SEEK_SET);
  88.   }
  89.   else
  90.     filesize_ = 0;
  91.  
  92.   version_ = tracks_ = clicks_ = trackno_ = 0;
  93.   tracklen_ = 0;
  94. }
  95.  
  96.  
  97. MidiRead::~MidiRead()
  98. {
  99.   if (f_ && shouldclose_)
  100.     fclose(f_);
  101. }
  102.  
  103. int MidiRead::runhead()
  104. {
  105.   if (!f_)
  106.   {
  107.     error("file not open");
  108.     return 0;
  109.   }
  110.   seek(0);
  111.   if (getlong() != MThd)
  112.   {
  113.     error("missing midi header MThd");
  114.     return 0;
  115.   }
  116.  
  117.   if (getlong() == 6)
  118.   {
  119.     version_ = getword();
  120.     tracks_ = getword();
  121.     clicks_ = getword();
  122.     head(version_, tracks_, clicks_);
  123.   }
  124.   else
  125.   {
  126.     error("illegal midi header");
  127.     return 0;
  128.   }
  129.   return 1;
  130. }
  131.  
  132. int MidiRead::run()
  133. {
  134.   pos_ = curpos_;
  135.   if (!runhead())
  136.     return 0;
  137.   pos_ = curpos_;
  138.   for (trackno_ = 1; trackno_ <= tracks_; trackno_++)
  139.     if (!runtrack(trackno_))
  140.       return 0;
  141.   if (curpos_ >= filesize_)
  142.     percent(percent_ = 100);
  143.   endmidi();
  144.   return 1;
  145. }
  146.  
  147. int MidiRead::runevent(long trackend)
  148. {
  149. int midicode;
  150.  
  151.   pos_ = curpos_;
  152.  
  153.   unsigned char *c = need(1);
  154.   if (!c || c[0] >= 0x80 || lastcode_ < 0)
  155.     midicode = getbyte();
  156.   else
  157.     midicode = lastcode_;
  158.  
  159.   if (midicode < 0)
  160.     return 0;
  161.  
  162.   switch(midicode)
  163.   {
  164.   case 0xf0: // sysex
  165.     {
  166.       int syslen = scansysevent(trackend - curpos_);
  167.       if (!syslen)
  168.       {
  169.     error("end of sysex not found or sysex too large");
  170.     return 0;
  171.       }
  172.       unsigned char* sysdata = get(syslen);
  173.       if ((options_ & OPTION_NOSYSEVENTS) == 0)
  174.       {
  175.     if (issysex(sysex_gmreset, sysdata, syslen))
  176.       gmreset();
  177.     else if (issysex(sysex_gsreset, sysdata, syslen))
  178.       gsreset();
  179.     else if (issysex(sysex_gsexit, sysdata, syslen))
  180.       gsexit();
  181.     else if (issysex(sysex_xgreset, sysdata, syslen))
  182.       xgreset();
  183.     else
  184.       sysex(syslen, sysdata);
  185.       }
  186.       else if ((options_ & OPTION_NOREALTIMEEVENTS) == 0)
  187.     sysex(syslen, sysdata);
  188.       else
  189.     event(0xf0, syslen, sysdata);
  190.     }
  191.     break;
  192.   case 0xf2:
  193.   {
  194.     c = get(2); if (!c) return 0;
  195.     if ((options_ & OPTION_NOREALTIMEEVENTS) == 0)
  196.       songpos((unsigned(c[1]) << 7) + unsigned(c[0]));
  197.     else
  198.       event(0xf2, 2, c);
  199.     break;
  200.   }
  201.   case 0xf3:
  202.     c = get(1); if (!c) return 0;
  203.     if ((options_ & OPTION_NOREALTIMEEVENTS) == 0)
  204.       songselect(*c);
  205.     else
  206.       event(0xf3, 1, c);
  207.     break;
  208.   case 0xf6:
  209.     if ((options_ & OPTION_NOREALTIMEEVENTS) == 0)
  210.       tunerequest();
  211.     else
  212.       event(0xf6);
  213.     break;
  214.   case 0xf8:
  215.     if ((options_ & OPTION_NOREALTIMEEVENTS) == 0)
  216.       timingclock();
  217.     else
  218.       event(0xf8);
  219.     break;
  220.   case 0xfa:
  221.     if ((options_ & OPTION_NOREALTIMEEVENTS) == 0)
  222.       start();
  223.     else
  224.       event(0xfa);
  225.     break;
  226.   case 0xfb:
  227.     if ((options_ & OPTION_NOREALTIMEEVENTS) == 0)
  228.       cont();
  229.     else
  230.       event(0xfb);
  231.     break;
  232.   case 0xfc:
  233.     if ((options_ & OPTION_NOREALTIMEEVENTS) == 0)
  234.       stop();
  235.     else
  236.       event(0xfc);
  237.     break;
  238.   case 0xfe:
  239.     if ((options_ & OPTION_NOREALTIMEEVENTS) == 0)
  240.       activesense();
  241.     else
  242.       event(0xfe);
  243.     break;
  244.   case 0xff:
  245.     {
  246.     int c;
  247.     unsigned long endpos;
  248.     int len;
  249.  
  250.       c = getbyte();
  251.       len = (int)getdelta();
  252.       endpos = curpos_ + len;
  253.       if (options_ & OPTION_NOREALTIMEEVENTS)
  254.       {
  255.     len += curdeltalen_ + 1;
  256.     seek(curpos_ - curdeltalen_ - 1);
  257.     event(0xff, len, get(len));
  258.       }
  259.       else if (options_ & OPTION_NOMETAEVENTS)
  260.     meta(c, len, get(len));
  261.       else
  262.     switch(c)
  263.     {
  264.     case 0:
  265.       if (len == 2)
  266.         seqnumber(getword());
  267.       else
  268.         meta(c, len, get(len));
  269.       break;
  270.     case meta_text:
  271.       text(c, len, "text", get(len)); break;
  272.     case meta_copyright:
  273.       text(c, len, "copyright", get(len));  break;
  274.     case meta_trackname:
  275.       text(c, len, "trackname", get(len)); break;
  276.     case meta_instrument:
  277.       text(c, len, "instrument", get(len)); break;
  278.     case meta_lyric:
  279.       text(c, len, "lyric", get(len)); break;
  280.     case meta_marker:
  281.       text(c, len, "marker", get(len)); break;
  282.     case meta_cuepoint:
  283.       text(c, len, "cuepoint", get(len)); break;
  284.     case 8:
  285.     case 9:
  286.     case 10:
  287.     case 11:
  288.     case 12:
  289.     case 13:
  290.     case 14:
  291.     case 15:
  292.       text(c, len, 0, get(len)); break;
  293.     case 0x20:
  294.       if (len == 1)
  295.         prefixchannel(getbyte());
  296.       else
  297.         meta(c, len, get(len));
  298.       break;
  299.     case 0x21:
  300.       if (len == 1)
  301.         prefixport(getbyte());
  302.       else
  303.         meta(c, len, get(len));
  304.       break;
  305.     case 0x2F:
  306.       end();
  307.       break;
  308.     case 0x51:
  309.       tempo(gettri());
  310.       break;
  311.     case 0x54:
  312.       if (len == 5)
  313.       {
  314.       unsigned char *s = get(len);
  315.  
  316.         smpteofs(s[0], s[1], s[2], s[3], s[4]);
  317.       }
  318.       else
  319.         meta(c, len, get(len));
  320.       break;
  321.     case 0x58:
  322.       if (len == 4)
  323.       {
  324.       int nom, clicksperbeat, notes32perbeat, log2denom;
  325.  
  326.         nom = getbyte();
  327.         log2denom = getbyte();
  328.  
  329.         clicksperbeat = getbyte();
  330.         notes32perbeat = getbyte();
  331.         tact(nom, 1 << log2denom, clicksperbeat, notes32perbeat);
  332.       }
  333.       else
  334.         meta(c, len, get(len));
  335.       break;
  336.     case 0x59:
  337.       if (len == 2)
  338.       {
  339.       signed char s[2];
  340.  
  341.         s[0] = (signed char)getbyte(); // sf
  342.         s[1] = (signed char)getbyte(); // mi
  343.         if (s[0] >= -7 && s[0] <= +7 && s[1] >= 0 && s[1] <= 1)
  344.           key(s[0], s[1]);
  345.         else
  346.           meta(c, len, (unsigned char*)s);
  347.       }
  348.       else
  349.         meta(c, len, get(len));
  350.       break;
  351.     default:
  352.       meta(c, len, get(len));
  353.       break;
  354.     }
  355.       seek(endpos);
  356.     }
  357.     break;
  358.   default:
  359.     {
  360.       if (midicode < 0)
  361.     return 0;
  362.       if (midicode < 0x80)
  363.       {
  364.       char msg[30];
  365.  
  366.     sprintf(msg, "illegal midi command %02X", midicode);
  367.     error(msg);
  368.     return 0;
  369.       }
  370.       int channel = midicode & 0x0F;
  371.       int cmd = midicode & 0xF0;
  372.  
  373.       switch(cmd)
  374.       {
  375.       case 0x80:
  376.       case 0x90:
  377.     {
  378.     unsigned char* c;
  379.  
  380.       lastcode_ = midicode;
  381.       c = get(2); if (!c) return 0;
  382.       if (options_ & OPTION_NONOTEEVENTS)
  383.         event(midicode, 2, c);
  384.       else
  385.       {
  386.         if (cmd == 0x80 || c[1] == 0)
  387.           noteoff(channel, c[0], c[1]);
  388.         else
  389.           noteon(channel, c[0], c[1]);
  390.       }
  391.     }
  392.     break;
  393.       case 0xA0:
  394.     {
  395.     unsigned char* p = get(2); if (!p) return 0;
  396.  
  397.       lastcode_ = midicode;
  398.  
  399.       if (options_ & OPTION_NOPOLYEVENTS)
  400.         event(midicode, 2, p);
  401.       else
  402.       {
  403.         polyaftertouch(channel, p[0], p[1]);
  404.       }
  405.     }
  406.     break;
  407.       case 0xB0:
  408.     {
  409.     unsigned char* p = get(2); if (!p) return 0;
  410.  
  411.       lastcode_ = midicode;
  412.       if (options_ & OPTION_NOCONTROLEVENTS)
  413.         event(midicode, 2, p);
  414.       else if (options_ & OPTION_NOCONTROLS)
  415.         control(channel, p[0], p[1]);
  416.       else
  417.         switch(p[0])
  418.         {
  419.         case ctrl_highbank: highbank(channel, p[1]); break;
  420.         case ctrl_wheel: wheel(channel, p[1]); break;
  421.         case ctrl_breath: breath(channel, p[1]); break;
  422.         case ctrl_foot: foot(channel, p[1]); break;
  423.         case ctrl_portamentotime: portamentotime(channel, p[1]); break;
  424.         case ctrl_data: data(channel, p[1]); break;
  425.         case ctrl_volume: volume(channel, p[1]); break;
  426.         case ctrl_balance: balance(channel, p[1]); break;
  427.         case ctrl_expression: expression(channel, p[1]); break;
  428.         case ctrl_lowbank: lowbank(channel, p[1]); break;
  429.         case ctrl_hold: hold(channel, p[1]); break;
  430.         case ctrl_reverb: reverb(channel, p[1]); break;
  431.         case ctrl_chorus: chorus(channel, p[1]); break;
  432.         case ctrl_datainc: datainc(channel, p[1]); break;
  433.         case ctrl_datadec: datadec(channel, p[1]); break;
  434.         case ctrl_lowrpn: lowrpn(channel, p[1]); break;
  435.         case ctrl_highrpn:
  436.           {
  437.           unsigned char *c = need(8);
  438.  
  439.         if (c &&
  440.           c[0] == 0 && c[1] == midicode && c[2] == ctrl_lowrpn && c[3] == 0 &&
  441.           c[4] == 0 && c[5] == midicode && c[6] == ctrl_data)
  442.         {
  443.           c = get(8);
  444.           pitchbendrange(channel, c[7]);
  445.         }
  446.         else
  447.           highrpn(channel, p[1]);
  448.         break;
  449.           }
  450.         default:
  451.           control(channel, p[0], p[1]);
  452.           break;
  453.         }
  454.       break;
  455.     }
  456.  
  457.       case 0xC0:
  458.     {
  459.     unsigned char* p = get(1); if (!p) return 0;
  460.  
  461.       lastcode_ = midicode;
  462.       if (options_ & OPTION_NOPROGRAMEVENTS)
  463.         event(midicode, 1, p);
  464.       else
  465.         program(channel, p[0]);
  466.     }
  467.     break;
  468.       case 0xD0:
  469.     {
  470.     unsigned char* p = get(1); if (!p) return 0;
  471.  
  472.       lastcode_ = midicode;
  473.       if (options_ & OPTION_NOAFTERTOUCHEVENTS)
  474.         event(midicode, 1, p);
  475.       else
  476.         aftertouch(channel, p[0]);
  477.     }
  478.     break;
  479.       case 0xE0:
  480.     {
  481.     unsigned char* p = get(2); if (!p) return 0;
  482.     unsigned val = unsigned(p[0]) + (unsigned(p[1]) << 7);
  483.  
  484.       lastcode_ = midicode;
  485.       if (options_ & OPTION_NOPITCHBENDEVENTS)
  486.         event(midicode, 2, p);
  487.       else
  488.         pitchbend(channel, val);
  489.     }
  490.     break;
  491.       default:
  492.     {
  493.     char msg[30];
  494.  
  495.       sprintf(msg, "unexpected command byte %02X", midicode);
  496.       error(msg);
  497.       return 0;
  498.     }
  499.       }
  500.     }
  501.     break;
  502.   }
  503.   return (int)(curpos_ - pos_);
  504. }
  505.  
  506. int MidiRead::runtrack(int trackno)
  507. {
  508. unsigned long trackpos = curpos_, trackend;
  509.  
  510.   curtime_ = 0;
  511.   lastcode_ = -1;
  512.   pos_ = curpos_;
  513.   if (!f_)
  514.   {
  515.     error("file not open");
  516.     return 0;
  517.   }
  518.  
  519.   if (getlong() != MTrk)
  520.   {
  521.     error("missing midi track MTrk");
  522.     return 0;
  523.   }
  524.   tracklen_ = getlong();
  525.   track(trackno, tracklen_, curchannel_ = scanchannel(tracklen_));
  526.   trackpos = curpos_;
  527.   trackend = trackpos + tracklen_;
  528.   lastcode_ = -1;
  529.   if ((options_ & OPTION_NOEVENTS) == 0)
  530.   while (curpos_ < trackpos + tracklen_)
  531.   {
  532.     int newpercent = (int)((curpos_ * 100) / filesize_);
  533.     if (newpercent != percent_)
  534.       percent(percent_ = newpercent);
  535.  
  536.     unsigned long delta = getdelta();
  537.     if ( delta >= NOTREALISTIC_PAUSE )
  538.       warning("Unrealistic large pause found");
  539.     time(delta);
  540.     curtime_ += delta;
  541.     if (runevent(trackend) <= 0)
  542.       return 0;
  543.   }
  544.   seek(trackend);
  545.   pos_ = curpos_;
  546.   endtrack(trackno);
  547.   return 1;
  548. }
  549.  
  550. void MidiRead::setchannel(int channel)
  551. {
  552.   assert(channel >= -1 && channel <= 15);
  553.   curchannel_ = channel;
  554. }
  555.  
  556. int MidiRead::scansysevent(unsigned long maxlen)
  557. {
  558. int n = sizeof(buf_);
  559. unsigned char* c, *p;
  560. long savepos = curpos_;
  561. int len;
  562.  
  563.   if (maxlen < n)
  564.     n = (int)maxlen;
  565.   c = need(n);
  566.   if (!c)
  567.   {
  568.     n = buflen_;
  569.     c = need(n);
  570.     if (!c)
  571.       return 0;
  572.   }
  573.  
  574.   if (c[0] < 0x80)
  575.   {
  576.     // short sysex 0..127 bytes
  577.     len = c[0];
  578.     if (n >= len+1)
  579.     {
  580.       if (c[len] == 0xF7)
  581.     return len+1;
  582.     }
  583.   }
  584.   else if (n >= 2 && c[1] < 0x80)
  585.   {
  586.     // 128..16383 bytes
  587.     int len = (int(c[0] & 0x7f) << 7) + c[1];
  588.     if (n >= len + 2)
  589.     {
  590.       if (c[len+1] == 0xF7)
  591.     return len+2;
  592.     }
  593.   }
  594.   // sysex events without length information?
  595.   p = (unsigned char*)memchr(c, 0xF7, n);
  596.   if (p)
  597.     return (int)(p - c + 1);
  598.   seek(savepos);
  599.   return 0;
  600. }
  601.  
  602. int MidiRead::scanchannel(unsigned long maxlen)
  603. {
  604. int n = 512;
  605. unsigned char* c;
  606. int firstchannel = NOCHANNEL;
  607. int channel, code;
  608. long savepos = curpos_, endpos;
  609. int lastcode = -1;
  610.  
  611.   if (maxlen < n)
  612.     n = (int)maxlen;
  613.   c = need(n);
  614.   if (!c)
  615.     return -1;
  616.  
  617.   endpos = curpos_ + n;
  618.   while (curpos_ < endpos)
  619.   {
  620.     channel = NOCHANNEL;
  621.     getdelta();
  622.     c = need(1);
  623.     if (!c || *c >= 0x80 || lastcode < 0)
  624.       code = getbyte();
  625.     else
  626.       code = lastcode;
  627.     switch(code & 0xF0)
  628.     {
  629.     case 0xF0:
  630.       switch(code)
  631.       {
  632.       case 0xFF:
  633.     getbyte();
  634.     get((int)getdelta());
  635.     break;
  636.       case 0xf0: // sysex
  637.     {
  638.       int len = scansysevent(endpos-curpos_);
  639.       if (!get(len))
  640.         goto endscan;
  641.     }
  642.     break;
  643.       case 0xf2: get(2); break;
  644.       case 0xf3: getbyte(); break;
  645.       case 0xf6:
  646.       case 0xf8:
  647.       case 0xfa:
  648.       case 0xfb:
  649.       case 0xfc:
  650.       case 0xfe:
  651.     break;
  652.       default:
  653.     goto endscan;
  654.       }
  655.       break;
  656.     case 0x80:
  657.     case 0x90:
  658.     case 0xA0:
  659.     case 0xB0:
  660.     case 0xE0:
  661.       channel = code & 15;
  662.       get(2);
  663.       break;
  664.     case 0xC0:
  665.     case 0xD0:
  666.       channel = code & 15;
  667.       getbyte();
  668.       break;
  669.     default:
  670.       goto endscan;
  671.     }
  672.     if (code < 0xf0)
  673.       lastcode = code;
  674.     if (channel >= 0)
  675.     {
  676.       if (firstchannel < 0)
  677.     firstchannel = channel;
  678.       else if (channel != firstchannel)
  679.       {
  680.     firstchannel = MULTICHANNEL;
  681.     break;
  682.       }
  683.     }
  684.   }
  685. endscan:
  686.   seek(savepos);
  687.   return firstchannel;
  688. }
  689.  
  690. int MidiRead::getbyte()
  691. {
  692. unsigned char* c = get(1);
  693.  
  694.   if (c)
  695.     return *c;
  696.   return -1;
  697. }
  698.  
  699. unsigned MidiRead::getword()
  700. {
  701. unsigned char* c = get(2);
  702. unsigned n = 0;
  703.  
  704.   if (c)
  705.   {
  706.     n = *c++;
  707.     n = (n << 8) + *c++;
  708.   }
  709.   return n;
  710. }
  711.  
  712. unsigned long MidiRead::gettri()
  713. {
  714. unsigned char* c = get(3);
  715. unsigned long n = 0;
  716.  
  717.   if (c)
  718.   {
  719.     n = *c++;
  720.     n = (n << 8) + *c++;
  721.     n = (n << 8) + *c++;
  722.   }
  723.   return n;
  724. }
  725.  
  726. unsigned long MidiRead::getlong()
  727. {
  728. unsigned char* c = get(4);
  729. unsigned long n = 0;
  730.  
  731.   if (c)
  732.   {
  733.     n = *c++;
  734.     n = (n << 8) + *c++;
  735.     n = (n << 8) + *c++;
  736.     n = (n << 8) + *c++;
  737.   }
  738.   return n;
  739. }
  740.  
  741. unsigned long MidiRead::getdelta()
  742. {
  743. unsigned long n = 0;
  744. int i = 0, c;
  745.  
  746.   curdeltalen_ = 0;
  747.   for (i = 0; i < 4; i++)
  748.   {
  749.     c = getbyte();
  750.     if (c < 0)
  751.     {
  752.       error("unexpected end of file");
  753.       return 0;
  754.     }
  755.     curdeltalen_++;
  756.     n = (n << 7) + (c & 0x7f);
  757.     if ((c & 0x80) == 0)
  758.       break;
  759.   }
  760.   return n;
  761. }
  762.  
  763. unsigned char* MidiRead::need(int n)
  764. {
  765.   assert(n >= 0);
  766.   if (n == 0)
  767.     return 0;
  768.   if (n > buflen_)
  769.   {
  770.     if (!f_)
  771.       return 0;
  772.     if (n > sizeof(buf_))
  773.       return 0;
  774.     if (n > sizeof(buf_) - bufpos_)
  775.     {
  776.       // move to beginning of buf
  777.       memmove(buf_, buf_ + bufpos_, buflen_);
  778.       bufpos_ = 0;
  779.     }
  780.     // add new data at end
  781.     if (sizeof(buf_) - bufpos_ - buflen_ > 0)
  782.     {
  783.       fseek(f_, curpos_+buflen_, SEEK_SET);
  784.       int l = fread(buf_+bufpos_+buflen_, 1, sizeof(buf_) - bufpos_ - buflen_, f_);
  785.       if (l > 0)
  786.     buflen_ += l;
  787.       else if (l == 0)
  788.     ;
  789.     }
  790.   }
  791.   if (n <= buflen_)
  792.     return buf_ + bufpos_;
  793.   return 0;
  794. }
  795.  
  796. unsigned char* MidiRead::get(int n)
  797. {
  798. unsigned char* s;
  799.  
  800.   s = need(n);
  801.   if (s)
  802.   {
  803.     buflen_ -= n;
  804.     bufpos_ += n;
  805.     curpos_ += n;
  806.   }
  807.   else if (n > sizeof(buf_))
  808.    warning("midi event larger than internal bufsize ignored");
  809.   else if (n > 0)
  810.   {
  811.     error("unexpected end of file");
  812.     exit(1);
  813.   }
  814.   return s;
  815. }
  816.  
  817. void MidiRead::seek(long pos)
  818. {
  819.   if (pos == curpos_ || pos < 0)
  820.     return;
  821.   if (pos >= curpos_ - bufpos_ && pos < curpos_ - bufpos_ + buflen_)
  822.   {
  823.   int n = (int)(pos - curpos_ + bufpos_);
  824.  
  825.     if (n < bufpos_)
  826.     {
  827.       buflen_ += bufpos_ - n;
  828.       bufpos_ -= bufpos_ - n;
  829.     }
  830.     else
  831.     {
  832.       buflen_ -= n - bufpos_;
  833.       bufpos_ += n - bufpos_;
  834.     }
  835.     curpos_ = pos;
  836.   }
  837.   else
  838.   {
  839.     fseek(f_, curpos_ = pos, SEEK_SET);
  840.     bufpos_ = buflen_ = 0;
  841.   }
  842. }
  843.  
  844. unsigned long MidiRead::microsec(unsigned long units, unsigned long msperbeat)
  845. {
  846.   assert(clicks_ != 0);   // call runhead() or run() first!
  847.  
  848.   if (units > msperbeat)
  849.     return (units / clicks_) * msperbeat;
  850.   else
  851.     return units * (msperbeat / clicks_);
  852. }
  853.  
  854.  
  855. long MidiRead::units(unsigned long microsec, unsigned long msperbeat)
  856. {
  857.   assert(clicks_ != 0);   // call runhead() or run() first!
  858.   assert(msperbeat > 0);  // invalid tempo!
  859.   int clicks = clicks_;
  860.   while ((msperbeat & 1) == 0)
  861.   {
  862.     if ((clicks & 1) == 0)
  863.       clicks >>= 1;
  864.     else if ((microsec & 1) == 0)
  865.       microsec >>= 1;
  866.     else
  867.       break;
  868.     msperbeat >>= 1;
  869.   }
  870.   if (microsec >= 0x10000L)
  871.     return (microsec / msperbeat) * clicks;
  872.   else
  873.     return (microsec * clicks) / msperbeat;
  874. }
  875.  
  876.  
  877. static char* GMProg[128] =
  878. {
  879.   "Piano", "BritePiano", "HammerPiano", "HonkeyTonk", "NewTines", "DigiPiano", "Harpsicord", "Clav",
  880.   "Celesta", "Glocken", "MusicBox", "Vibes", "Marimba", "Xylophon", "Tubular", "Santur",
  881.   "FullOrgan", "PercOrgan", "BX-3Organ", "ChurchPipe", "Positive", "Musette", "Harmonica", "Tango",
  882.   "ClassicGtr", "A.Guitar", "JazzGuitar", "CleanGtr", "MuteGuitar", "OverDrive", "DistGuitar", "RockMonics",
  883.   "JazzBass", "DeepBass", "PickBass", "FretLess", "SlapBass1", "SlapBass2", "SynthBass1", "SynthBass2",
  884.   "Violin", "Viola", "Cello", "ContraBass", "TremoloStr", "Pizzicato", "Harp", "Timpani",
  885.   "Marcato", "SlowString", "AnalogPad", "StringPad", "Choir", "DooVoice", "Voices", "OrchHit",
  886.   "Trumpet", "Trombone", "Tuba", "MutedTrumpet", "FrenchHorn", "Brass", "SynBrass1", "SynBrass2",
  887.   "SopranoSax", "AltoSax", "TenorSax", "BariSax", "SweetOboe", "EnglishHorn", "BasoonOboe", "Clarinet",
  888.   "Piccolo", "Flute", "Recorder", "PanFlute", "Bottle", "Shakuhachi","Whistle", "Ocarina",
  889.   "SquareWave", "SawWave", "SynCalinope", "SynChiff", "Charang", "AirChorus", "Rezzo4ths", "Bass&Lead",
  890.   "Fantasia", "WarmPad", "PolyPad", "GhostPad", "BowedGlas", "MetalPad", "HaloPad", "Sweep",
  891.   "IceRain", "SoundTrack", "Crystal", "Atmosphere", "Brightness", "Goblin", "EchoDrop", "StarTheme",
  892.   "Sitar", "Banjo", "Shamisen", "Koto", "Kalimba","Scotland","Fiddle", "Shanai",
  893.   "MetalBell", "Agogo", "SteelDrums", "Woodblock", "Taiko", "Tom", "SynthTom", "RevCymbal",
  894.   "FretNoise", "NoiseChiff", "Seashore", "Birds", "Telephone", "Helicopter", "Stadium!!", "GunShot"
  895. };
  896.  
  897. const char* MidiRead::notename(unsigned char note)
  898. {
  899. static char name[5];
  900. char* s = name;
  901.  
  902.   switch(note % 12)
  903.   {
  904.   case 0: *s++ = 'c'; break;
  905.   case 1: *s++ = 'c'; *s++ = '#'; break;
  906.   case 2: *s++ = 'd'; break;
  907.   case 3: *s++ = 'd'; *s++ = '#'; break;
  908.   case 4: *s++ = 'e'; break;
  909.   case 5: *s++ = 'f'; break;
  910.   case 6: *s++ = 'f'; *s++ = '#'; break;
  911.   case 7: *s++ = 'g'; break;
  912.   case 8: *s++ = 'g'; *s++ = '#'; break;
  913.   case 9: *s++ = 'a'; break;
  914.   case 10: *s++ = 'a'; *s++ = '#'; break;
  915.   case 11: *s++ = 'b'; break; // former 'h': German language only
  916.   }
  917.  
  918.   sprintf(s, "%d", (note / 12)-1);  // octave  (assuming Piano C4 is 60)
  919.   return (const char*) name;
  920. }
  921.  
  922.  
  923. const char* MidiRead::progname(int n, int channel)
  924. {
  925. static char defname[10] = "";
  926.  
  927.   if (channel == 9) // drum programs
  928.   {
  929.     switch(n)
  930.     {
  931.     case 0:    return "Dr1";
  932.     case 0x10: return "Dr2";
  933.     case 0x19: return "Dr3";
  934.     case 0x20: return "Dr4";
  935.     case 0x28: return "Dr5";
  936.     case 0x40: return "Dr6";
  937.     case 0x18: return "Dr7";
  938.     case 0x30: return "Dr8";
  939.     }
  940.   }
  941.   else if (n >= 0 && n <= 127)
  942.     return GMProg[n];
  943. def:
  944.   sprintf(defname, "%d", n);
  945.   return (const char*)defname;
  946. }
  947.  
  948. void MidiRead::head(unsigned version, unsigned tracks, unsigned clicksperquarter)
  949. {
  950. }
  951.  
  952. void MidiRead::track(int trackno, long length, int channel)
  953. {
  954. }
  955.  
  956. void MidiRead::endtrack(int trackno)
  957. {
  958. }
  959.  
  960. void MidiRead::event(int what, int len, unsigned char* data)
  961. {
  962. }
  963.  
  964. void MidiRead::seqnumber(unsigned int seqno)
  965. {
  966. }
  967.  
  968. void MidiRead::smpteofs(int hour, int min, int sec, int frame, int fracframe)
  969. {
  970. }
  971.  
  972. void MidiRead::key(int signature, int isminor)
  973. {
  974. }
  975.  
  976. void MidiRead::prefixchannel(unsigned char channel)
  977. {
  978. }
  979.  
  980. void MidiRead::prefixport(unsigned char port)
  981. {
  982. }
  983.  
  984. void MidiRead::text(int what, int len, char* whattext, unsigned char* txt)
  985. {
  986. }
  987.  
  988. void MidiRead::meta(int what, int len, unsigned char* data)
  989. {
  990. }
  991.  
  992. void MidiRead::end()
  993. {
  994. }
  995.  
  996. void MidiRead::tact(int nom, int denom, int v1, int v2)
  997. {
  998. }
  999.  
  1000. void MidiRead::tempo(unsigned long ticks)
  1001. {
  1002. }
  1003.  
  1004. void MidiRead::program(int channel, int program)
  1005. {
  1006. }
  1007.  
  1008. void MidiRead::control(int channel, int what, int value)
  1009. {
  1010. }
  1011.  
  1012. void MidiRead::highbank(int channel, int val)
  1013. {
  1014.   control(channel, ctrl_highbank, val);
  1015. }
  1016.  
  1017. void MidiRead::wheel(int channel, int val)
  1018. {
  1019.   control(channel, ctrl_wheel, val);
  1020. }
  1021.  
  1022. void MidiRead::breath(int channel, int val)
  1023. {
  1024.   control(channel, ctrl_breath, val);
  1025. }
  1026.  
  1027. void MidiRead::foot(int channel, int val)
  1028. {
  1029.   control(channel, ctrl_foot, val);
  1030. }
  1031.  
  1032. void MidiRead::portamentotime(int channel, int val)
  1033. {
  1034.   control(channel, ctrl_portamentotime, val);
  1035. }
  1036.  
  1037. void MidiRead::data(int channel, int val)
  1038. {
  1039.   control(channel, ctrl_data, val);
  1040. }
  1041.  
  1042. void MidiRead::volume(int channel, int val)
  1043. {
  1044.   control(channel, ctrl_volume, val);
  1045. }
  1046.  
  1047. void MidiRead::balance(int channel, int val)
  1048. {
  1049.   control(channel, ctrl_balance, val);
  1050. }
  1051.  
  1052. void MidiRead::expression(int channel, int val)
  1053. {
  1054.   control(channel, ctrl_expression, val);
  1055. }
  1056.  
  1057. void MidiRead::lowbank(int channel, int val)
  1058. {
  1059.   control(channel, ctrl_lowbank, val);
  1060. }
  1061.  
  1062. void MidiRead::hold(int channel, int val)
  1063. {
  1064.   control(channel, ctrl_hold, val);
  1065. }
  1066.  
  1067. void MidiRead::reverb(int channel, int val)
  1068. {
  1069.   control(channel, ctrl_reverb, val);
  1070. }
  1071.  
  1072. void MidiRead::chorus(int channel, int val)
  1073. {
  1074.   control(channel, ctrl_chorus, val);
  1075. }
  1076.  
  1077. void MidiRead::datainc(int channel, int val)
  1078. {
  1079.   control(channel, ctrl_datainc, val);
  1080. }
  1081.  
  1082. void MidiRead::datadec(int channel, int val)
  1083. {
  1084.   control(channel, ctrl_datadec, val);
  1085. }
  1086.  
  1087. void MidiRead::lowrpn(int channel, int val)
  1088. {
  1089.   control(channel, ctrl_lowrpn, val);
  1090. }
  1091.  
  1092. void MidiRead::highrpn(int channel, int val)
  1093. {
  1094.   control(channel, ctrl_highrpn, val);
  1095. }
  1096.  
  1097. void MidiRead::pitchbendrange(int channel, int halfnotes)
  1098. {
  1099.   highrpn(channel, 0);
  1100.   time(0);
  1101.   lowrpn(channel, 0);
  1102.   time(0);
  1103.   data(channel, halfnotes);
  1104. }
  1105.  
  1106. void MidiRead::noteon(int channel, int note, int vel)
  1107. {
  1108. }
  1109.  
  1110. void MidiRead::noteoff(int channel, int note, int vel)
  1111. {
  1112. }
  1113.  
  1114. void MidiRead::time(unsigned long ticks)
  1115. {
  1116. }
  1117.  
  1118. void MidiRead::pitchbend(int channel, int val)
  1119. {
  1120. }
  1121.  
  1122. void MidiRead::polyaftertouch(int channel, int note, int val)
  1123. {
  1124. }
  1125.  
  1126. void MidiRead::aftertouch(int channel, int val)
  1127. {
  1128. }
  1129.  
  1130. void MidiRead::songpos(unsigned pos)
  1131. {
  1132. }
  1133.  
  1134. void MidiRead::songselect(unsigned char song)
  1135. {
  1136. }
  1137.  
  1138. void MidiRead::tunerequest()
  1139. {
  1140. }
  1141.  
  1142. void MidiRead::timingclock()
  1143. {
  1144. }
  1145.  
  1146. void MidiRead::start()
  1147. {
  1148. }
  1149.  
  1150. void MidiRead::cont()
  1151. {
  1152. }
  1153.  
  1154. void MidiRead::stop()
  1155. {
  1156. }
  1157.  
  1158. void MidiRead::activesense()
  1159. {
  1160. }
  1161.  
  1162. void MidiRead::sysex(int syslen, unsigned char* sysdata)
  1163. {
  1164. }
  1165.  
  1166. void MidiRead::gmreset()
  1167. {
  1168. }
  1169.  
  1170. void MidiRead::gsreset()
  1171. {
  1172. }
  1173.  
  1174. void MidiRead::gsexit()
  1175. {
  1176. }
  1177.  
  1178. void MidiRead::xgreset()
  1179. {
  1180. }
  1181.  
  1182. void MidiRead::endmidi()
  1183. {
  1184. }
  1185.  
  1186. void MidiRead::percent(int perc)
  1187. {
  1188. }
  1189.  
  1190. void MidiRead::error(const char* msg)
  1191. {
  1192.   fprintf(stderr, "error: %s\n", msg);
  1193. }
  1194.  
  1195. void MidiRead::warning(const char* msg)
  1196. {
  1197.   fprintf(stderr, "warning: %s\n", msg);
  1198. }
  1199.  
  1200. FILE* MidiRead::getf()
  1201. {
  1202.   return f_;
  1203. }
  1204.  
  1205. // class MidiWrite
  1206.  
  1207. const char* MidiWrite::copyright()
  1208. {
  1209.   return (const char*)::copyright;
  1210. }
  1211.  
  1212. MidiWrite::MidiWrite(const char* filename)
  1213. {
  1214.   midiname_ = filename;
  1215.   if (midiname_)
  1216.     f_ = fopen(midiname_, WRITE_BINARY);
  1217.   else
  1218.     f_ = 0;
  1219.   trackpos_ = -1;
  1220.   curpos_ = 0;
  1221.   trackchannel_ = -1;
  1222.  
  1223.   bufpos_ = 0;
  1224.   buflen_ = 0;
  1225.   filesize_ = 0;
  1226.   trackcount_ = 0;
  1227.   curtime_ = curdelta_ = 0;
  1228.   lastcode_ = -1;
  1229.   clicks_ = 0;
  1230. }
  1231.  
  1232. MidiWrite::~MidiWrite()
  1233. {
  1234.   if (trackcount_ > 0)
  1235.   {
  1236.     seek(10);
  1237.     putword(trackcount_);
  1238.   }
  1239.   if (trackpos_ > 0)
  1240.     endtrack();
  1241.   flush();
  1242.   if (f_)
  1243.     fclose(f_);
  1244. }
  1245.  
  1246. void MidiWrite::head(int version, int tracks, unsigned clicksperquarter)
  1247. {
  1248.   seek(0);
  1249.   putlong(MThd);
  1250.   putlong(6);
  1251.   putword(version);
  1252.   putword(tracks);  // unknown
  1253.   putword(clicks_ = clicksperquarter);
  1254. }
  1255.  
  1256. void MidiWrite::track()
  1257. {
  1258.   if (trackpos_ > 0)
  1259.     endtrack();
  1260.   endtrack_ = 0;
  1261.   lastcode_ = -1;
  1262.   curtime_ = curdelta_ = 0;
  1263.   seek(trackpos_ = filesize_);
  1264.   putlong(MTrk);
  1265.   putlong(0); // unknown yet
  1266.   trackcount_++;
  1267. }
  1268.  
  1269. void MidiWrite::endtrack()
  1270. {
  1271.   seek(filesize_);
  1272.   if (!endtrack_)
  1273.      end();
  1274.   if (trackpos_ <= 0)
  1275.     return;
  1276.   seek(trackpos_+4);
  1277.   putlong(filesize_ - trackpos_ - 8);
  1278.   trackpos_ = 0;
  1279. }
  1280.  
  1281. void MidiWrite::event(int what, int len, unsigned char* data)
  1282. {
  1283.   puttime();
  1284.   putcode(what);
  1285.   put(len, data);
  1286. }
  1287.  
  1288. void MidiWrite::prefixchannel(unsigned char channel)
  1289. {
  1290.   meta(0x20, 1, &channel);
  1291. }
  1292.  
  1293. void MidiWrite::prefixport(unsigned char port)
  1294. {
  1295.   meta(0x21, 1, &port);
  1296. }
  1297.  
  1298. void MidiWrite::text(int what, int len, unsigned char* txt)
  1299. {
  1300.   if (len < 0)
  1301.     len = strlen(txt);
  1302.   meta(what, len, txt);
  1303. }
  1304.  
  1305. void MidiWrite::meta(int what, int len, unsigned char* data)
  1306. {
  1307.   puttime();
  1308.   putcode(0xff);
  1309.   putbyte(what);
  1310.   putdelta(len);
  1311.   put(len, data);
  1312. }
  1313.  
  1314. void MidiWrite::end()
  1315. {
  1316.   if (endtrack_)  // don't need end of track event twice
  1317.     return;
  1318.   endtrack_ = 1;
  1319.   meta(0x2f, 0, 0);
  1320. }
  1321.  
  1322. void MidiWrite::tact(int nom, int denom, int v1, int v2)
  1323. {
  1324. int log2denom;
  1325.  
  1326.   switch(denom)
  1327.   {
  1328.   case 1:    log2denom = 0; break;
  1329.   case 2:    log2denom = 1; break;
  1330.   case 4:    log2denom = 2; break;
  1331.   case 8:    log2denom = 3; break;
  1332.   case 16:   log2denom = 4; break;
  1333.   case 32:   log2denom = 5; break;
  1334.   case 64:   log2denom = 6; break;
  1335.   case 128:  log2denom = 7; break;
  1336.   case 256:  log2denom = 8; break;
  1337.   default:
  1338.     log2denom = 2;
  1339.     assert((1 << log2denom) == denom);
  1340.   }
  1341.   puttime();
  1342.   putcode(0xff);
  1343.   putbyte(0x58);
  1344.   putbyte(4);
  1345.   putbyte(nom);
  1346.   putbyte(log2denom);
  1347.   putbyte(v1);
  1348.   putbyte(v2);
  1349. }
  1350.  
  1351. void MidiWrite::seqnumber(unsigned int seqno)
  1352. {
  1353.   puttime();
  1354.   putcode(0xff);
  1355.   putbyte(0x00);
  1356.   putbyte(2);
  1357.   putword(seqno);
  1358. }
  1359.  
  1360. void MidiWrite::smpteofs(int hour, int min, int sec, int frame, int fracframe)
  1361. {
  1362.   puttime();
  1363.   putcode(0xff);
  1364.   putbyte(0x54);
  1365.   putbyte(5);
  1366.   putbyte(hour);
  1367.   putbyte(min);
  1368.   putbyte(sec);
  1369.   putbyte(frame);
  1370.   putbyte(fracframe);
  1371. }
  1372.  
  1373. void MidiWrite::key(int signature, int isminor)
  1374. {
  1375.   puttime();
  1376.   putcode(0xff);
  1377.   putbyte(0x59);
  1378.   putbyte(2);
  1379.   putbyte((signed char)signature);
  1380.   putbyte((signed char)isminor);
  1381. }
  1382.  
  1383. void MidiWrite::tempo(unsigned long ticks)
  1384. {
  1385.   puttime();
  1386.   putcode(0xff);
  1387.   putbyte(0x51);
  1388.   putbyte(3);
  1389.   puttri(ticks);
  1390. }
  1391.  
  1392. void MidiWrite::program(int channel, int prg)
  1393. {
  1394.   assert(channel >= 0 && channel < 16);
  1395.   puttime();
  1396.   putcode(0xC0 + channel);
  1397.   putbyte(prg);
  1398. }
  1399.  
  1400. void MidiWrite::control(int channel, int what, int val)
  1401. {
  1402.   assert(channel >= 0 && channel < 16);
  1403.   puttime();
  1404.   putcode(0xB0 + channel);
  1405.   putbyte(what);
  1406.   putbyte(val);
  1407. }
  1408.  
  1409. void MidiWrite::highbank(int channel, int val)
  1410. {
  1411.   control(channel, ctrl_highbank, val);
  1412. }
  1413.  
  1414. void MidiWrite::wheel(int channel, int val)
  1415. {
  1416.   control(channel, ctrl_wheel, val);
  1417. }
  1418.  
  1419. void MidiWrite::breath(int channel, int val)
  1420. {
  1421.   control(channel, ctrl_breath, val);
  1422. }
  1423.  
  1424. void MidiWrite::foot(int channel, int val)
  1425. {
  1426.   control(channel, ctrl_foot, val);
  1427. }
  1428.  
  1429. void MidiWrite::portamentotime(int channel, int val)
  1430. {
  1431.   control(channel, ctrl_portamentotime, val);
  1432. }
  1433.  
  1434. void MidiWrite::data(int channel, int val)
  1435. {
  1436.   control(channel, ctrl_data, val);
  1437. }
  1438.  
  1439. void MidiWrite::volume(int channel, int val)
  1440. {
  1441.   control(channel, ctrl_volume, val);
  1442. }
  1443.  
  1444. void MidiWrite::balance(int channel, int val)
  1445. {
  1446.   control(channel, ctrl_balance, val);
  1447. }
  1448.  
  1449. void MidiWrite::expression(int channel, int val)
  1450. {
  1451.   control(channel, ctrl_expression, val);
  1452. }
  1453.  
  1454. void MidiWrite::lowbank(int channel, int val)
  1455. {
  1456.   control(channel, ctrl_lowbank, val);
  1457. }
  1458.  
  1459. void MidiWrite::hold(int channel, int val)
  1460. {
  1461.   control(channel, ctrl_hold, val);
  1462. }
  1463.  
  1464. void MidiWrite::reverb(int channel, int val)
  1465. {
  1466.   control(channel, ctrl_reverb, val);
  1467. }
  1468.  
  1469. void MidiWrite::chorus(int channel, int val)
  1470. {
  1471.   control(channel, ctrl_chorus, val);
  1472. }
  1473.  
  1474. void MidiWrite::datainc(int channel, int val)
  1475. {
  1476.   control(channel, ctrl_datainc, val);
  1477. }
  1478.  
  1479. void MidiWrite::datadec(int channel, int val)
  1480. {
  1481.   control(channel, ctrl_datadec, val);
  1482. }
  1483.  
  1484. void MidiWrite::lowrpn(int channel, int val)
  1485. {
  1486.   control(channel, ctrl_lowrpn, val);
  1487. }
  1488.  
  1489. void MidiWrite::highrpn(int channel, int val)
  1490. {
  1491.   control(channel, ctrl_highrpn, val);
  1492. }
  1493.  
  1494. void MidiWrite::noteon(int channel, int note, int vel)
  1495. {
  1496.   assert(channel >= 0 && channel < 16);
  1497.   puttime();
  1498.   putcode(0x90+channel);
  1499.   putbyte(note);
  1500.   putbyte(vel);
  1501. }
  1502.  
  1503. void MidiWrite::noteoff(int channel, int note, int vel)
  1504. {
  1505.   assert(channel >= 0 && channel < 16);
  1506.   puttime();
  1507.   if (vel != 0 || lastcode_ < 0 || (lastcode_ & 0xF0) != 0x90)
  1508.     putcode(0x80+channel);
  1509.   else
  1510.     putcode(0x90+channel);  // vel == 0!
  1511.   putbyte(note);
  1512.   putbyte(vel);
  1513. }
  1514.  
  1515. void MidiWrite::time(unsigned long ticks)
  1516. {
  1517.   if ( ticks >= NOTREALISTIC_PAUSE )
  1518.     warning("generating unrealistic large pause");
  1519.   curdelta_ += ticks;
  1520.   curtime_ += ticks;
  1521. }
  1522.  
  1523. void MidiWrite::cleardelta()
  1524. {
  1525.   curtime_ -= curdelta_;
  1526.   curdelta_ = 0;
  1527. }
  1528.  
  1529. void MidiWrite::pitchbend(int channel, int val)
  1530. {
  1531.   assert(channel >= 0 && channel < 16);
  1532.   puttime();
  1533.   putcode(0xE0 + channel);
  1534.   putbyte(val & 0x7F);
  1535.   putbyte((val >> 7) & 0x7F);
  1536. }
  1537.  
  1538. void MidiWrite::polyaftertouch(int channel, int note, int val)
  1539. {
  1540.   assert(channel >= 0 && channel < 16);
  1541.   puttime();
  1542.   putcode(0xA0 + channel);
  1543.   putbyte(note);
  1544.   putbyte(val);
  1545. }
  1546.  
  1547. void MidiWrite::aftertouch(int channel, int val)
  1548. {
  1549.   assert(channel >= 0 && channel < 16);
  1550.   puttime();
  1551.   putcode(0xD0 + channel);
  1552.   putbyte(val);
  1553. }
  1554.  
  1555. void MidiWrite::songpos(unsigned pos)
  1556. {
  1557.   puttime();
  1558.   putcode(0xF2);
  1559.   putbyte(pos & 0x7F);
  1560.   putbyte((pos >> 7) & 0x7F);
  1561. }
  1562.  
  1563. void MidiWrite::songselect(unsigned char song)
  1564. {
  1565.   puttime();
  1566.   putcode(0xF3);
  1567.   putbyte(song);
  1568. }
  1569.  
  1570. void MidiWrite::tunerequest()
  1571. {
  1572.   puttime();
  1573.   putcode(0xf6);
  1574. }
  1575.  
  1576. void MidiWrite::timingclock()
  1577. {
  1578.   puttime();
  1579.   putcode(0xf8);
  1580. }
  1581.  
  1582. void MidiWrite::start()
  1583. {
  1584.   puttime();
  1585.   putcode(0xfa);
  1586. }
  1587.  
  1588. void MidiWrite::cont()
  1589. {
  1590.   puttime();
  1591.   putcode(0xfb);
  1592. }
  1593.  
  1594. void MidiWrite::stop()
  1595. {
  1596.   puttime();
  1597.   putcode(0xfc);
  1598. }
  1599.  
  1600. void MidiWrite::activesense()
  1601. {
  1602.   puttime();
  1603.   putcode(0xfe);
  1604. }
  1605.  
  1606. void MidiWrite::sysex(int syslen, unsigned char* sysdata)
  1607. {
  1608.   puttime();
  1609.   putcode(0xf0);
  1610.   if (*sysdata == 0xF0)
  1611.   {
  1612.     syslen--;
  1613.     sysdata++;
  1614.   }
  1615.   put(syslen, sysdata);
  1616. }
  1617.  
  1618. void MidiWrite::gmreset()
  1619. {
  1620.   sysex(sysexlen(sysex_gmreset), sysex_gmreset);
  1621. }
  1622.  
  1623. void MidiWrite::xgreset()
  1624. {
  1625.   sysex(sysexlen(sysex_xgreset), sysex_xgreset);
  1626. }
  1627.  
  1628. void MidiWrite::gsreset()
  1629. {
  1630.   sysex(sysexlen(sysex_gsreset), sysex_gsreset);
  1631. }
  1632.  
  1633. void MidiWrite::gsexit()
  1634. {
  1635.   sysex(sysexlen(sysex_gsexit), sysex_gsexit);
  1636. }
  1637.  
  1638. void MidiWrite::pitchbendrange(int channel, int halfnotes)
  1639. {
  1640.   highrpn(channel, 0);
  1641.   lowrpn(channel, 0);
  1642.   data(channel, halfnotes);
  1643. }
  1644.  
  1645. void MidiWrite::putbyte(unsigned char val)
  1646. {
  1647.   put(1, &val);
  1648. }
  1649.  
  1650. void MidiWrite::putcode(unsigned char code)
  1651. {
  1652. int put;
  1653.  
  1654.   assert(code >= 0x80);
  1655.  
  1656.   if (compress)
  1657.     put = !(code == lastcode_ && code <= 0x9f);
  1658.   else
  1659.     put = 1;
  1660.   if (put)
  1661.     putbyte(code);
  1662.   lastcode_ = code;
  1663. }
  1664.  
  1665. static unsigned char c[4];
  1666.  
  1667. void MidiWrite::putword(unsigned val)
  1668. {
  1669.   c[1] = (unsigned char)(val & 0xff); val >>= 8;
  1670.   c[0] = (unsigned char)(val & 0xff);
  1671.   put(2, c);
  1672. }
  1673.  
  1674. void MidiWrite::puttri(unsigned long val)
  1675. {
  1676.   c[2] = (unsigned char)(val & 0xff); val >>= 8;
  1677.   c[1] = (unsigned char)(val & 0xff); val >>= 8;
  1678.   c[0] = (unsigned char)(val & 0xff);
  1679.   put(3, c);
  1680. }
  1681.  
  1682. void MidiWrite::putlong(unsigned long val)
  1683. {
  1684.   c[3] = (unsigned char)(val & 0xff); val >>= 8;
  1685.   c[2] = (unsigned char)(val & 0xff); val >>= 8;
  1686.   c[1] = (unsigned char)(val & 0xff); val >>= 8;
  1687.   c[0] = (unsigned char)(val & 0xff);
  1688.   put(4, c);
  1689. }
  1690.  
  1691. void MidiWrite::putdelta(unsigned long val)
  1692. {
  1693.   int i = 0, j = 3;
  1694.   while (i < 4)
  1695.   {
  1696.     c[j] = val & 0x7F;
  1697.     if (j < 3)
  1698.       c[j] |= 0x80;
  1699.     val >>= 7;
  1700.     i++;
  1701.     if (!val)
  1702.       break;
  1703.     j--;
  1704.   }
  1705.   put(i, c+j);
  1706. }
  1707.  
  1708. void MidiWrite::puttime()
  1709. {
  1710.   putdelta(curdelta_);
  1711.   curdelta_ = 0;
  1712. }
  1713.  
  1714. void MidiWrite::flush()
  1715. {
  1716.   if (buflen_ > 0)
  1717.   {
  1718.     fseek(f_, curpos_ - bufpos_, SEEK_SET);
  1719.     if (fwrite(buf_, buflen_, 1, f_) != 1)
  1720.       error("write error (maybe disk full)");
  1721.     assert(ftell(f_) == curpos_ - bufpos_ + buflen_);
  1722.     bufpos_ = buflen_ = 0;
  1723.   }
  1724. }
  1725.  
  1726. void MidiWrite::put(int len, unsigned char* c)
  1727. {
  1728.   if (len <= 0)
  1729.     return;
  1730.   if (c == 0 || len > sizeof(buf_))
  1731.     return;
  1732.   if (sizeof(buf_) - bufpos_ < len)
  1733.     flush();
  1734.   memcpy(buf_+bufpos_, c, len);
  1735.   bufpos_+=len;
  1736.   if (bufpos_ > buflen_)
  1737.     buflen_ = bufpos_;
  1738.   curpos_+= len;
  1739.   if (curpos_ > filesize_)
  1740.     filesize_ = curpos_;
  1741. }
  1742.  
  1743. void MidiWrite::seek(long pos)
  1744. {
  1745.   assert(pos >= 0 && pos <= filesize_);
  1746.   if (curpos_ == pos)
  1747.     return;
  1748.   if (pos >= curpos_-bufpos_ && pos <= curpos_-bufpos_+buflen_)
  1749.   {
  1750.     bufpos_ = (int)(pos - (curpos_-bufpos_));
  1751.     curpos_ = pos;
  1752.     return;
  1753.   }
  1754.   flush();
  1755.   curpos_ = pos;
  1756. }
  1757.  
  1758. FILE* MidiWrite::getf()
  1759. {
  1760.   return f_;
  1761. }
  1762.  
  1763. void MidiWrite::error(const char* msg)
  1764. {
  1765.   fprintf(stderr, "midi write error: %s\n", msg);
  1766. }
  1767.  
  1768. void MidiWrite::warning(const char* msg)
  1769. {
  1770.   fprintf(stderr, "midi write warning: %s\n", msg);
  1771. }
  1772.  
  1773. int MidiWrite::unitsperquarter()
  1774. {
  1775.   return clicks_;
  1776. }
  1777.  
  1778. MidiCopy::MidiCopy(const char* filename, FILE* f) : MidiRead(filename, f)
  1779. {
  1780.   dest_ = NULL;
  1781.   for (int c = 0; c < 16; c++)
  1782.     mapchannel_[c] = c;        // no change
  1783. }
  1784.  
  1785. void MidiCopy::head(unsigned version, unsigned tracks, unsigned clicksperquarter)
  1786. {
  1787.   if (dest_)
  1788.     dest_->head(version, 0, clicksperquarter);
  1789. }
  1790.  
  1791. void MidiCopy::track(int trackno, long length, int channel)
  1792. {
  1793.   if (dest_)
  1794.     dest_->track();
  1795. }
  1796.  
  1797. void MidiCopy::endtrack(int trackno)
  1798. {
  1799.   if (dest_)
  1800.     dest_->endtrack();
  1801. }
  1802.  
  1803. void MidiCopy::event(int what, int len, unsigned char* data)
  1804. {
  1805.   if (dest_)
  1806.     dest_->event(what, len, data);
  1807. }
  1808.  
  1809.  
  1810. void MidiCopy::seqnumber(unsigned int seqno)
  1811. {
  1812.   if (dest_)
  1813.     dest_->seqnumber(seqno);
  1814. }
  1815.  
  1816. void MidiCopy::smpteofs(int hour, int min, int sec, int frame, int fracframe)
  1817. {
  1818.   if (dest_)
  1819.     dest_->smpteofs(hour, min, sec, frame, fracframe);
  1820. }
  1821.  
  1822. void MidiCopy::key(int signature, int isminor)
  1823. {
  1824.   if (dest_)
  1825.     dest_->key(signature, isminor);
  1826. }
  1827.  
  1828. void MidiCopy::prefixchannel(unsigned char channel)
  1829. {
  1830.   if (dest_ && mapchannel_[channel] >= 0)
  1831.     dest_->prefixchannel(mapchannel_[channel]);
  1832. }
  1833.  
  1834. void MidiCopy::prefixport(unsigned char port)
  1835. {
  1836.   if (dest_)
  1837.     dest_->prefixport(port);
  1838. }
  1839.  
  1840. void MidiCopy::text(int what, int len, char* whattext, unsigned char* txt)
  1841. {
  1842.   if (dest_)
  1843.     dest_->text(what, len, txt);
  1844. }
  1845.  
  1846. void MidiCopy::meta(int what, int len, unsigned char* data)
  1847. {
  1848.   if (dest_)
  1849.     dest_->meta(what, len, data);
  1850. }
  1851.  
  1852. void MidiCopy::end()
  1853. {
  1854.   if (dest_)
  1855.     dest_->end();
  1856. }
  1857.  
  1858. void MidiCopy::tact(int nom, int denom, int v1, int v2)
  1859. {
  1860.   if (dest_)
  1861.     dest_->tact(nom, denom, v1,v2);
  1862. }
  1863.  
  1864. void MidiCopy::tempo(unsigned long ticks)
  1865. {
  1866.   if (dest_)
  1867.     dest_->tempo(ticks);
  1868. }
  1869.  
  1870. void MidiCopy::program(int channel, int program)
  1871. {
  1872.   if (dest_ && mapchannel_[channel] >= 0)
  1873.     dest_->program(mapchannel_[channel], program);
  1874. }
  1875.  
  1876. void MidiCopy::control(int channel, int what, int value)
  1877. {
  1878.   if (dest_ && mapchannel_[channel] >= 0)
  1879.     dest_->control(mapchannel_[channel], what, value);
  1880. }
  1881.  
  1882. void MidiCopy::highbank(int channel, int val)
  1883. {
  1884.   if (dest_ && mapchannel_[channel] >= 0)
  1885.     dest_->highbank(mapchannel_[channel], val);
  1886. }
  1887.  
  1888. void MidiCopy::wheel(int channel, int val)
  1889. {
  1890.   if (dest_ && mapchannel_[channel] >= 0)
  1891.     dest_->wheel(mapchannel_[channel], val);
  1892. }
  1893.  
  1894. void MidiCopy::breath(int channel, int val)
  1895. {
  1896.   if (dest_ && mapchannel_[channel] >= 0)
  1897.     dest_->wheel(mapchannel_[channel], val);
  1898. }
  1899.  
  1900. void MidiCopy::foot(int channel, int val)
  1901. {
  1902.   if (dest_ && mapchannel_[channel] >= 0)
  1903.     dest_->foot(mapchannel_[channel], val);
  1904. }
  1905.  
  1906. void MidiCopy::portamentotime(int channel, int val)
  1907. {
  1908.   if (dest_ && mapchannel_[channel] >= 0)
  1909.     dest_->portamentotime(mapchannel_[channel], val);
  1910. }
  1911.  
  1912. void MidiCopy::data(int channel, int val)
  1913. {
  1914.   if (dest_ && mapchannel_[channel] >= 0)
  1915.     dest_->data(mapchannel_[channel], val);
  1916. }
  1917.  
  1918. void MidiCopy::volume(int channel, int val)
  1919. {
  1920.   if (dest_ && mapchannel_[channel] >= 0)
  1921.     dest_->volume(mapchannel_[channel], val);
  1922. }
  1923.  
  1924. void MidiCopy::balance(int channel, int val)
  1925. {
  1926.   if (dest_ && mapchannel_[channel] >= 0)
  1927.     dest_->balance(mapchannel_[channel], val);
  1928. }
  1929.  
  1930. void MidiCopy::expression(int channel, int val)
  1931. {
  1932.   if (dest_ && mapchannel_[channel] >= 0)
  1933.     dest_->expression(mapchannel_[channel], val);
  1934. }
  1935.  
  1936. void MidiCopy::lowbank(int channel, int val)
  1937. {
  1938.   if (dest_ && mapchannel_[channel] >= 0)
  1939.     dest_->lowbank(mapchannel_[channel], val);
  1940. }
  1941.  
  1942. void MidiCopy::hold(int channel, int val)
  1943. {
  1944.   if (dest_ && mapchannel_[channel] >= 0)
  1945.     dest_->hold(mapchannel_[channel], val);
  1946. }
  1947.  
  1948. void MidiCopy::reverb(int channel, int val)
  1949. {
  1950.   if (dest_ && mapchannel_[channel] >= 0)
  1951.     dest_->reverb(mapchannel_[channel], val);
  1952. }
  1953.                       
  1954. void MidiCopy::chorus(int channel, int val)
  1955. {
  1956.   if (dest_ && mapchannel_[channel] >= 0)
  1957.     dest_->chorus(mapchannel_[channel], val);
  1958. }
  1959.  
  1960. void MidiCopy::datainc(int channel, int val)
  1961. {
  1962.   if (dest_ && mapchannel_[channel] >= 0)
  1963.     dest_->datainc(mapchannel_[channel], val);
  1964. }
  1965.  
  1966. void MidiCopy::datadec(int channel, int val)
  1967. {
  1968.   if (dest_ && mapchannel_[channel] >= 0)
  1969.     dest_->datadec(mapchannel_[channel], val);
  1970. }
  1971.  
  1972.  
  1973. void MidiCopy::noteon(int channel, int note, int vel)
  1974. {
  1975.   if (dest_ && mapchannel_[channel] >= 0)
  1976.     dest_->noteon(mapchannel_[channel], note, vel);
  1977. }
  1978.  
  1979. void MidiCopy::noteoff(int channel, int note, int vel)
  1980. {
  1981.   if (dest_ && mapchannel_[channel] >= 0)
  1982.     dest_->noteoff(mapchannel_[channel], note, vel);
  1983. }
  1984.  
  1985. void MidiCopy::time(unsigned long ticks)
  1986. {
  1987.   if (dest_)
  1988.     dest_->time(ticks);
  1989. }
  1990.  
  1991. void MidiCopy::pitchbend(int channel, int val)
  1992. {
  1993.   if (dest_ && mapchannel_[channel] >= 0)
  1994.     dest_->pitchbend(mapchannel_[channel],val);
  1995. }
  1996.  
  1997. void MidiCopy::polyaftertouch(int channel, int note, int val)
  1998. {
  1999.   if (dest_ && mapchannel_[channel] >= 0)
  2000.     dest_->polyaftertouch(mapchannel_[channel], note,  val);
  2001. }
  2002.  
  2003. void MidiCopy::aftertouch(int channel, int val)
  2004. {
  2005.   if (dest_ && mapchannel_[channel] >= 0)
  2006.     dest_->aftertouch(mapchannel_[channel],  val);
  2007. }
  2008.  
  2009. void MidiCopy::songpos(unsigned pos)
  2010. {
  2011.   if (dest_)
  2012.     dest_->songpos(pos);
  2013. }
  2014.  
  2015. void MidiCopy::songselect(unsigned char song)
  2016. {
  2017.   if (dest_)
  2018.     dest_->songselect(song);
  2019. }
  2020.  
  2021. void MidiCopy::tunerequest()
  2022. {
  2023.   if (dest_)
  2024.     dest_->tunerequest();
  2025.  
  2026. }
  2027.  
  2028. void MidiCopy::timingclock()
  2029. {
  2030.   if (dest_)
  2031.      dest_->timingclock();
  2032. }
  2033.  
  2034. void MidiCopy::start()
  2035. {
  2036.   if (dest_)
  2037.      dest_->start();
  2038. }
  2039.  
  2040. void MidiCopy::cont()
  2041. {
  2042.   if (dest_)
  2043.      dest_->cont();
  2044. }
  2045.  
  2046. void MidiCopy::stop()
  2047. {
  2048.   if (dest_)
  2049.      dest_->stop();
  2050. }
  2051.  
  2052. void MidiCopy::activesense()
  2053. {
  2054.   if (dest_)
  2055.      dest_->activesense();
  2056. }
  2057.  
  2058. void MidiCopy::sysex(int syslen, unsigned char* sysdata)
  2059. {
  2060.   if (dest_)
  2061.      dest_->sysex(syslen, sysdata);
  2062. }
  2063.  
  2064. void MidiCopy::xgreset()
  2065. {
  2066.   if (dest_)
  2067.      dest_->xgreset();
  2068. }
  2069.  
  2070. void MidiCopy::gmreset()
  2071. {
  2072.   if (dest_)
  2073.      dest_->gmreset();
  2074. }
  2075.  
  2076. void MidiCopy::gsreset()
  2077. {
  2078.   if (dest_)
  2079.      dest_->gsreset();
  2080. }
  2081.  
  2082. void MidiCopy::gsexit()
  2083. {
  2084.   if (dest_)
  2085.      dest_->gsexit();
  2086. }
  2087.  
  2088. void MidiCopy::setoutput(MidiWrite* dest)
  2089. {
  2090.   assert(dest != NULL && dest->getf() != NULL); // need a valid MidiWrite instance
  2091.   dest_ = dest;
  2092. }
  2093.  
  2094. void MidiCopy::stopoutput()
  2095. {
  2096.   dest_ = NULL; // owner is responsible for deleting the MidiWrite object
  2097. }
  2098.  
  2099. MidiWrite* MidiCopy::getoutput()
  2100. {
  2101.   return dest_;
  2102. }
  2103.  
  2104. void MidiCopy::mapchannel(int channel, int newchannel)
  2105. {
  2106.   assert(channel >= 0 && channel < 16);
  2107.   assert(newchannel >= 0 && newchannel < 16);
  2108.   mapchannel_[channel] = newchannel;
  2109. }
  2110.  
  2111. void MidiCopy::ignorechannel(int channel)
  2112. {
  2113.   assert(channel >= 0 && channel < 16);
  2114.   mapchannel_[channel] = -1;
  2115. }
  2116.